// Copyright [2020] <unknown>
#include <bits/stdc++.h>
using namespace std;
// #define ONLINE_JUDGE
#ifndef ONLINE_JUDGE
#define dbg(x...) { cerr << "\033[32;1m" << #x << " -> "; err(x); }
void err() { cerr << "\033[39;0m" << endl; }
template<typename T, typename... A>
void err(T a, A... x) { cerr << a << ' '; err(x...); }
#else
#define dbg(...)
#endif

#define sz(x) ((int)x.size())

typedef long long LL;


const int N = 2e6+50;

const int MOD = 1e9+7;

LL f[N], invf[N];
int n, m, l;

int prime[N], pcnt;
int minp[N], mu[N], phi[N];

void init() {
    pcnt = 0;
    mu[1] = 1;
    phi[1] = 0;
    for (int i = 2; i < N; ++i) {
        if (!minp[i]) {
            mu[i] = -1;
            phi[i] = i - 1;
            minp[i] = i;
            prime[pcnt++] = i;
        }

        for (int j = 0; j < pcnt; ++j) {
            LL nextp = 1LL * i * prime[j];
            if (nextp >= N)
                break;
            if (!minp[nextp])
                minp[nextp] = prime[j];
            if (i % prime[j] == 0) {
                phi[nextp] = phi[i] * prime[j];
                mu[nextp] = 0;
                break;
            } else {
                mu[nextp] = -mu[i];
                phi[nextp] = phi[i] * (prime[j] - 1);
            }
        }
    }
}

// int cnt(int a[], int n) {
//     static bool vis[N];
//     memset(vis, 0, sizeof vis);
//     int ans = 0;
//     for (int i=0; i<n; ++i) {
//         if (!vis[i]) {
//             vis[i] = 1;
//             ++ans;
//             for (int now=a[i]; !vis[now]; now=a[now]) {
//                 vis[now] = 1;
//             }
//         }
//     }
//     return ans;
// }

// struct P {
//     vector<int> a;
//     bool operator < (const P &other) const {
//         int n = a.size();
//         for (int i=0; i<n; ++i) {
//             if (a[i] != other.a[i])
//                 return a[i] < other.a[i];
//         }
//         return false;
//     }

//     P shift(int i) {
//         int n = 0;
//         vector<int> b(n);
//         for (int i=0; i<n; ++i) {

//         }
//     }
// };

// int test(int n) {
//     int a[N];
//     for (int i=0; i<n; ++i) {
//         a[i] = i;
//     }
//     int ans = 0;
//     int c[N];
//     memset(c, 0, sizeof c);
//     do {
//         c[cnt(a, n)]++;
//     } while (next_permutation(a, a+n));
//     dbg(n);
//     for (int i=1; i<=n; ++i)
//         dbg(i, c[i]);
//     return ans;
// }

LL bin(LL a, LL b, LL p = MOD) {
    LL res = 1;
    for (; b; b>>=1, a=a*a%p)
        if (b & 1)
            res = res * a % MOD;
    return res;
}

LL C(int n, int m) {
    // assert(n >= m);
    if (n < m) return 0;
    return f[n] * invf[n-m] % MOD * invf[m] % MOD;
}

int main(int argc, char const *argv[]) {
    // code
    // for (int i=1; i<=8; ++i)
    //     dbg(i, test(i));
    init();

    f[1] = 1;
    for (int i=2; i<N; ++i)
        f[i] = f[i-1] * i % MOD;
    invf[N-1] = bin(f[N-1], MOD-2, MOD);
    for (int i=N-2; i>=1; --i)
        invf[i] = invf[i+1] * (i+1) % MOD;
    f[0] = invf[0] = 1;

    scanf("%d%d%d", &n, &m, &l);
    LL ans = 0;
    static LL p[N];
    p[0] = 1;
    for (int i=1; i<N; ++i)
        p[i] = p[i-1] * m % MOD;
    if (n == l) {
        for (int i=1; i<=l; ++i) {
            int x = __gcd(i, l);
            ans = (ans + p[x]) % MOD;
        }
        ans = ans * bin(l, MOD-2, MOD) % MOD;
    } else {
        ans = C(n+m-1, m-1);
        if (l % 2)
            ans += C(m, n);
        ans %= MOD;
    }
    cout << ans << endl;
    return 0;
}
